home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Internet Tools 1993 July / Internet Tools.iso / RockRidge / mail / pp / pp-6.0 / Tools / mu / argh.c next >
Encoding:
C/C++ Source or Header  |  1991-12-18  |  15.4 KB  |  637 lines
  1. /* argh.c    argument handling routines */
  2.  
  3. # ifndef lint
  4. static char Rcsid[] = "@(#)$Header: /xtel/pp/pp-beta/Tools/mu/RCS/argh.c,v 6.0 1991/12/18 20:31:54 jpo Rel $";
  5. # endif
  6.  
  7. /*
  8.  * $Header: /xtel/pp/pp-beta/Tools/mu/RCS/argh.c,v 6.0 1991/12/18 20:31:54 jpo Rel $
  9.  *
  10.  * $Log: argh.c,v $
  11.  * Revision 6.0  1991/12/18  20:31:54  jpo
  12.  * Release 6.0
  13.  *
  14.  */
  15.  
  16.  
  17.  
  18. #include "argh.h"
  19. #include "util.h"
  20.  
  21. extern    struct    argdef    arg[];        /* defined in main program */
  22. static    struct    argfull *argfull;    /* to point to full array */
  23. static    struct    arginst *ai;        /* to point to linked lists */
  24. static    asource;            /* holds scan_args counter */
  25.  
  26. struct    sort {
  27.     struct argfull    *tag;
  28.     char        *string;
  29. } argsort[MAXFLAGS];        /* to hold sort sequence */
  30.  
  31. static    char    *aerrlist[] = {
  32.  
  33.     /* usage : printf(aerrlist[i],a,b,c,d);  char *a,*b,*c,*d */
  34.  
  35.     "unknown error\n",                        /* 0 */
  36.     "flag %s not known\n",                        /* 1 */
  37.     "flag %s ambiguous match\n",                    /* 2 */
  38.     "invalid type for flag %s  - fix source\n",            /* 3 */
  39.     "limit of %s argument instances - aborted\n",            /* 4 */
  40.     "flag %s value should be adjacent to '='\n",            /* 5 */
  41.     "flag %s (type adjacent) not followed by value\n",        /* 6 */
  42.     "flag %s - adjacent arguments not allowed without '='\n",    /* 7 */
  43.     "flag %s (type next) must use next argument\n",            /* 8 */
  44.     "flag %s (type next) has no next argument\n",            /* 9 */
  45.     "flag %s (type 0 valued ) should not have value\n",        /*10 */
  46.     "flag %s (type %s valued) has no value%s\n",            /*11 */
  47.     "flag %s (type %s valued) has only %s value%s\n",        /*12 */
  48.     "flag %s (type 1 or more) must have at least one value\n",    /*13 */
  49.     "duplicate flag %s in table - fix source\n",            /*14 */
  50.     "ambiguous flags %s and %s - fix source\n"            /*15 */
  51. };
  52.  
  53. /* ----------------------------------------------------------------- */
  54. int    prep_args(arg)        /* scan flags list, count, set length,
  55.                 sort and calculate match length */
  56. struct    argdef    arg[];
  57. {
  58.     struct    argdef    *a;
  59.     struct    argfull    *af;
  60.     int    i,j,cur,prev;
  61.  
  62.     for(i=0,a=arg; a->flag[0]; i++,a++);    /* count arg[] */
  63.     flagcount=i;    /* flagcount is structure member for 'others' */
  64.  
  65.     argfull = (struct argfull *) calloc( (flagcount+1), sizeof(struct argfull) );
  66.  
  67.     asource=1;    /* initialise scan_counter */
  68.  
  69.     /* printf("flagcount %d\n",flagcount); */
  70.     
  71.     for(i=0,a=arg,af=argfull; i<=flagcount; i++,a++,af++) {
  72.  
  73.         af->flag    = a->flag;
  74.         af->function    = a->function;
  75.         af->type    = a->type;
  76.         af->match    = a->match;
  77.         af->length    = 0;
  78.         af->count    = 0;
  79.         af->first    = NULL;
  80.         af->last    = NULL;
  81.  
  82.         if ( index(VALIDTYPES,af->type) == NULL ) {
  83.             arg_error(3,af->flag);
  84.             cleanquit();
  85.         }
  86.  
  87.         argsort[i].tag    = af;         /* pointer to structure */
  88.         argsort[i].string = af->flag;    /* pointer to flag chars. */
  89.         af->length=strlen(af->flag);
  90.         /* printf("length %d  match %d  type %c  %s\n",af->length, af->match, af->type, af->flag); */
  91.     }
  92.  
  93.     quick_string(argsort,flagcount+1);    /* sort array argsort in flag order */
  94.  
  95.     argsort[flagcount+1].tag = argsort[0].tag;    /* both ends point to "" */
  96.  
  97. /*
  98.     for(j=0;j<=flagcount; j++) {
  99.         printf("argsort j=%d string=%s\n",j,argsort[j].string);
  100.     }
  101. */
  102.  
  103.     for(j=0,prev=0; j<=flagcount; j++,prev=cur) {
  104.         af = argsort[j].tag;
  105.         cur=mincmp(af->flag,(argsort[j+1].tag)->flag);
  106.         if(!cur) {
  107.             arg_error(14,af->flag);
  108.             return(-1);
  109.         }
  110.         if (j && cur > af->length) {
  111.             arg_error(15,af->flag,(argsort[j+1].tag)->flag);
  112.             return(-1);
  113.         }
  114.         /* printf("sort %d  %s  type %c  cur %d  prev %d\n",j,af,af->type,cur,prev); */
  115.         if(af->match <= 0) {
  116.             if(af->match < 0)
  117.                 af->match=af->length;
  118.             else {
  119.                 af->match = (cur < prev) ? (prev) : (cur);
  120.             }
  121.         }
  122.     }
  123.     return(0);
  124. }
  125.  
  126. /* ----------------------------------------------------------------- */
  127. int    scan_args(argc,argv)    /* returns incremented scan_counter */
  128. int    argc;
  129. char    **argv;
  130. {
  131.     struct    argdef    *a=arg;        /* passed in */
  132.     struct    argfull    *af=argfull;    /* generated internally */
  133.     char    **argvtemp=argv;
  134.     char    *cp,*v;
  135.     char    nullbyte='\0';
  136.     int    i,c,ca,offset,n;
  137.  
  138.     if (!flagcount) {
  139.         if ( (i=prep_args(arg)) )
  140.             cleanquit();
  141.     }
  142. /*
  143.     The argument list is scanned, checking each argument against
  144.     entries in structure 'argfull'.  Linked lists are generated 
  145.     for all arguments of the same type, in command line sequence.
  146.     Any parameters which do not match one of the ->type's are
  147.     accumulated in a list of 'others'.
  148.  
  149.      sample            flag
  150.     -samplearg        complete match (adj) ok  ( unless !ADJARGS )
  151.     -sample arg        complete match (next) ok
  152.            ^ offset
  153.     -sample=arg        complete match with = (adj) ok
  154.     -sample= arg        complete match with = (next) - error - "value should be adjacent to '='"
  155.             ^ offset
  156.     -samarg            incomplete match (adj) - error - "flag not known/ambiguous match"
  157.     -sam arg        incomplete match (next) ok
  158.     -sam=arg        incomplete match with =arg ok
  159.     -sam= arg        incomplete match with = (next) arg - error - "value should be adjacent to '='"
  160.          ^ offset
  161. */
  162.     for(argcpi=1; argcpi < argc; argcpi++) {    /* loop until arguments exhausted */
  163.         cp = *++argvtemp;
  164.         if (**argvtemp == FLAGCHAR) {
  165.  
  166.             /* now test against each allowed type in turn */
  167.  
  168.             for(i=0,af=argfull; i < flagcount; i++,af++) {
  169.                 if (!mystrncmp(af->flag, &cp[1], af->match)) {
  170.  
  171.                     /* found a match */
  172.  
  173.                     if(( v = index(cp,EQUCHAR) ) != NULL) {
  174.                         if(*++v == '\0') {
  175.                             arg_error(5,af->flag);
  176.                             break;
  177.                         }
  178.                     }
  179.                     else {
  180.                         v = &nullbyte;
  181.                         if(af->length == af->match) {
  182.                             v=cp + af->match + 1;        /* value starts at end of match (could point at '\0') */
  183.                         }
  184.                         else {
  185.  
  186.                             if ( (ONECHARARGS) && (af->match == 1)) { /* allow one char */
  187.                                 v = cp + 2 ;
  188.                             }
  189.                             else {
  190.  
  191.                                 /* have matched on af->match chars  - try on ca chars */
  192.  
  193.                                 ca=strlen(cp)-1;        /* length of current argument less '-' */
  194.                                 if (mystrncmp(af->flag, &cp[1], ca))    { /* doesn't match */
  195.  
  196.                                     /* now - try on af->length chars */
  197.  
  198.                                     if (mystrncmp(af->flag, &cp[1], af->length))    { /* doesn't match */
  199.                                         arg_error(2,af->flag);
  200.                                         break;
  201.                                     }
  202.                                     else {    /* does match af->length chars */
  203.                                         v=cp + af->length + 1;
  204.                                     }
  205.                                 }
  206.                                 else {    /* does match ca chars */
  207.                                     v=cp + ca + 1;
  208.                                 }
  209.                             }
  210.                         }
  211.                         if ((*v != '\0') && !ADJARGS) {
  212.                             arg_error(7,af->flag);
  213.                             break;
  214.                         }
  215.                     }    /* endif == EQUCHAR */
  216.                     offset=(v-cp);
  217.                     c = count_to_flag(argc,argvtemp,v);
  218.                     /* printf ("flag %s c-flag%s\n",af->flag,digit_word(c)); */
  219.  
  220.                     switch(af->type) {
  221.  
  222.                     case 'a':
  223.                         if (*v == '\0')
  224.                             arg_error(6,af->flag);
  225.                         else
  226.                             take_next(1,af,&argvtemp,v,offset);
  227.                         break;
  228.  
  229.                     case 'n':
  230.                         if (*v != '\0') {
  231.                             arg_error(8,af->flag);
  232.                             break;
  233.                         }
  234.                         if (c < 1 ) {
  235.                             arg_error(9,af->flag);
  236.                             break;
  237.                         }
  238.                         else
  239.                             take_next(1,af,&argvtemp,v,offset);
  240.                         break;
  241.  
  242.                     case 'm':
  243.                         if (c < 1 )
  244.                             arg_error(13,af->flag);
  245.                         else
  246.                             take_next(c,af,&argvtemp,v,offset);
  247.                         break;
  248.  
  249.                     case 'z':
  250.                         take_next(c,af,&argvtemp,v,offset);
  251.                         break;
  252.                             
  253.                     case '0':
  254.                         if (c && ZEROCHECK)
  255.                             arg_error(10,af->flag);
  256.                         else
  257.                             take_next(1,af,&argvtemp,*argvtemp,0); /* from add_link */
  258.                         break;
  259.  
  260.                     default    :
  261.                         /* digit flag type 1-9 */
  262.                         n = af->type - '0';
  263.                         if( c < n ) {
  264.                             if ( !c )
  265.                                 arg_error(11,af->flag,digit_word(n),(n == 1 ? "" : "s" ) );
  266.                             else {
  267.                                 arg_error(12,af->flag,digit_word(n),digit_word(c),(c == 1 ? "" : "s" ));
  268.                             }
  269.                         }
  270.                         else
  271.                             take_next(n,af,&argvtemp,v,offset);
  272.                         break;
  273.  
  274.                     }    /* end switch */
  275.                     break;
  276.                 }
  277.                 else { /* no match */
  278.                     if (i == flagcount-1 ) { /* have tried all flags */
  279.                         arg_error(1,cp);
  280.                         /* take_next(1,&arg[flagcount],&argvtemp,*argvtemp,0); */
  281.                         take_next(1,af+flagcount,&argvtemp,*argvtemp,0);    /* make it an 'other' */
  282.                     }
  283.                 }        /* end if */
  284.             }            /* end for */
  285.         }                /* end if == FLAGCHAR */
  286.         else {
  287.             /* this is an 'other' */
  288.             /* add argi to list pointed to by *next */
  289.             take_next(1,af+flagcount,&argvtemp,*argvtemp,0); /* from add_link */
  290.         }
  291.     }    /* endfor */
  292.     return(asource++);    /* return value THEN increment */
  293. }
  294.  
  295. /* ----------------------------------------------------------------- */
  296. void    add_link(af,v,offset,argn,argof)    /* extend linked list for flagnumber
  297.                         ONLY called from take_next() */
  298. struct    argfull    *af;
  299. char    *v;
  300. int    offset,argn,argof;
  301. {
  302.     static    int argi_count=0;    /* to count number of entries */
  303.  
  304.     ai = (struct arginst *) malloc(sizeof(struct arginst));
  305.  
  306.     /* printf("add_link: %s %x %d %d\n",af->flag,ai,argcpi,offset); */
  307.     if(!af->first) {
  308.         af->first=ai;
  309.     }
  310.     else {
  311.          (af->last)->next=ai;
  312.     }
  313.     ai->argcp=v;        /* actual string of argument value */
  314.     ai->argci=argcpi;
  315.     ai->argoi=offset;
  316.     ai->argn=argn;
  317.     ai->argof=argof;
  318.     ai->argsrc=asource;    /* indicates source of value */
  319.     ai->argused=0;
  320.     ai->next=NULL;
  321.     af->count++;
  322.     af->last=ai;
  323.     argi_count++;
  324.     if ( argi_count > MAXARGS ) {
  325.         arg_error(4,digit_word(MAXARGS));
  326.         cleanquit();
  327.     }
  328.     return;
  329. }
  330.  
  331. /* ----------------------------------------------------------------- */
  332. void    take_next(i,af,p,v,offset)    /* take next i arguments  ( assumes i > 0 )
  333.                        offset used if first argument is adjacent  */
  334. int    i,offset;
  335. struct    argfull    *af;
  336. char    ***p,*v;
  337. {
  338.     int    argn=1;        /* argn of argof=i */
  339.     int    argof=i;
  340.     
  341.     if (*v != '\0') {
  342.         add_link(af,v,offset,argn,argof);
  343.         i--;
  344.         argn++;
  345.     }
  346.     while(i) {
  347.         (*p)++;
  348.         argcpi++;
  349.         add_link(af,**p,0,argn,argof);
  350.         i--;
  351.         argn++;
  352.     }
  353.     return;
  354. }
  355.  
  356. /* ----------------------------------------------------------------- */
  357. void    arg_error(i,a,b,c,d)    /* general error message output */
  358. int    i;
  359. char    *a,*b,*c,*d;
  360. {
  361.     printf("argh! : ");
  362.     printf(aerrlist[i],a,b,c,d);
  363.     return;
  364. }
  365.  
  366. /* ----------------------------------------------------------------- */
  367. int    count_to_flag(argc,argvtemp,v)    /* count arguments up to next flag */
  368. int    argc;
  369. char    **argvtemp,*v;
  370. {
  371.     int    i;
  372.     i=argcpi;
  373.     argvtemp++;
  374.     /* NOTE: this relies on left-right evaluation with && */
  375.     while ((i < (argc-1)) && (**argvtemp != FLAGCHAR)) {
  376.         /* printf("loop   i %d  **argvtemp %c\n",i,**argvtemp); */
  377.         i++;
  378.         argvtemp++;
  379.     };
  380.     return(i-argcpi    + ( *v == '\0' ? 0 : 1 ));
  381. }
  382. /* ----------------------------------------------------------------- */
  383. void    show_args(argc,argv,fp,af)    /* display (sorted) list of flags, arguments found */
  384. int    argc;
  385. char    **argv;
  386. FILE    *fp;
  387. struct    argfull    *af;    /* points to command which invoked display */
  388. {
  389.     int    i;
  390.  
  391.     fprintf(fp,"\n%s : ",ARGHVER);
  392.     fprintf(fp,"%d flags  %d command line arguments",flagcount,argc);
  393.     for(i=0; i <= flagcount; i++) {
  394.         af = argsort[i].tag;
  395.         fprintf(fp,(*af->flag == '\0') ? "\nothers ":"\nflag   ");
  396.         fprintf(fp,"%-15s\011type %c\011match %d\011count %d : ",af->flag,af->type,af->match,af->count);
  397.         ai=af->first;
  398.         while (ai) {
  399.             /* fprintf(fp," %s",&argv[ai->argci][ai->argoi]); */
  400.             fprintf(fp," %s",ai->argcp);
  401.             ai=ai->next;
  402.         }
  403.     }
  404.     fprintf(fp,"\n");
  405.     return;
  406. }
  407. /* ----------------------------------------------------------------- */
  408. void    call_args(argc,argv,fp)    /* call any routines corresponding
  409.                    to arguments found in flag
  410.                    declaration order */
  411. FILE    *fp;
  412. int    argc;
  413. char    **argv;
  414. {
  415.     struct    argfull    *af;
  416.     int    i;
  417.  
  418.     for(i=0,af=argfull; i <= flagcount; i++,af++) {
  419.         if((af->count) && (af->function != NULL)) {
  420.             (*af->function)(argc,argv,fp,af);
  421.         }
  422.     }
  423.     return;
  424. }
  425. /* ----------------------------------------------------------------- */
  426. void    list_args(fp,f)        /* list arguments for flag f to file fp */
  427. FILE    *fp;
  428. char    *f;
  429. {
  430.     char    *p;
  431.     fprintf(fp,"%s_args : ",f);
  432.     while( p = next_arg(f) ) {
  433.         fprintf(fp,"<%s>",p);
  434.     }
  435.     fprintf(fp,"\n");
  436.     return;
  437. }
  438. /* ----------------------------------------------------------------- */
  439. char    *next_arg(f)        /* get next arg for flag f - no ambiguity
  440.                 in specification of f allowed  - any level */
  441. char    *f;
  442. {
  443.     int    n,of;        /* place holders */
  444.     int    s = 0;        /* source not significant */
  445.     return(nextc_arg(f,s,&n,&of));
  446. }
  447.  
  448. /* ----------------------------------------------------------------- */
  449. char    *nextc_arg(f,s,n,of)        /* get next arg for flag f with counts - no ambiguity
  450.                     in specification of f allowed */
  451. char    *f;
  452. int    s,*n,*of;    /* source, which, of how many */
  453. {
  454.     static    char    lastf[MAXFLAGLEN]="?";    /* to compare with last call */
  455.     static    int    source;            /* ditto */
  456.     struct    argfull    *af=argfull;
  457.     int    i;
  458.  
  459.     if ((mystrcmp(f,lastf)) || (source != s)) {    /* new value */
  460.         /* printf("new value <%s>{%d}, old value <%s>{%d}\n",f,s,lastf,source); */
  461.         strcpy(lastf,f);    /* store for future reference */
  462.         source = s;        /* ditto */
  463.         if (*f == '\0') {    /* null string for 'others' */
  464.             ai=(af+flagcount)->first;
  465.         }
  466.         else {
  467.             for(i=0,af=argfull; i <= flagcount; i++,af++) {
  468.                 if(mystrcmp(f,af->flag))
  469.                     continue;
  470.                 /* printf("flag found"); */
  471.                 ai=af->first;
  472.                 break;
  473.             }
  474.         }
  475.     }
  476.     else {
  477.         ai=ai->next;
  478.     }
  479.  
  480.     if(source) {    /* searching for source */
  481.         while ( ai && (ai->argsrc != source)) 
  482.             ai=ai->next;
  483.     }
  484.     if(ai) {
  485.         if(source)
  486.             ai->argsrc = 0;    /* clear out source indicator */
  487.         *n    = ai->argn;
  488.         *of    = ai->argof;
  489.         return(ai->argcp);
  490.     }
  491.     else {
  492.         *n    = 0;
  493.         *of    = 0;
  494.         return(NULL);
  495.     }
  496. }
  497.  
  498. /* ----------------------------------------------------------------- */
  499. char    *digit_word(x)    /* DANGER - do not expect to work for two
  500.             calls both >10 or negative in same printf() */
  501. int    x;
  502. {
  503.     int sign;
  504.     static char buf[10];
  505.     static char *words[]= {
  506.         "zero",
  507.         "one",
  508.         "two",
  509.         "three",
  510.         "four",
  511.         "five",
  512.         "six",
  513.         "seven",
  514.         "eight",
  515.         "nine"
  516.     };
  517.     if (x < 0) {
  518.         sign = TRUE;
  519.         x = -x;
  520.     }
  521.     else
  522.         sign = FALSE;
  523.  
  524.     if (x < 10)
  525.         if (!sign)
  526.             return(words[x]);
  527.         else
  528.             sprintf( buf, "%s%s", (sign? "minus ":""), words[x] );
  529.     else
  530.         sprintf( buf, "%s%d", (sign? "minus ":""), x );
  531.     return( buf );
  532. }
  533. /* ----------------------------------------------------------------- */
  534. void    quick_string(a,count)    /* quick sort string array
  535.                 a[i]->tag     is tag pointer
  536.                 a[i]->string    is pointer to character string
  537.                         - to be sorted */
  538. struct    sort    a[];
  539. int    count;
  540. {
  541.     qs_string(a,0,count-1,count);
  542. }
  543. void    qs_string(a,left,right,count)    /* recursive sort */
  544. struct    sort    a[];
  545. int    left,right,count;
  546. {
  547.     register int    i,j;
  548.     register char    *x,*y;    /* pointers to characters being sorted */
  549.  
  550.     i=left;
  551.     j=right;
  552.     x=a[(left+right)/2].string;
  553.  
  554.     do {
  555.         while(mystrcmp(a[i].string,x)<0 && i<right) i++;
  556.         while(mystrcmp(a[j].string,x)>0 && j>left) j--;
  557.         if( i <= j ) {
  558.  
  559.             y = a[i].string;
  560.             a[count+1].tag = a[i].tag;    /* swap tag pointers */
  561.  
  562.             a[i].string = a[j].string;
  563.             a[i].tag = a[j].tag;
  564.  
  565.             a[j].string = y;
  566.             a[j].tag = a[count+1].tag;
  567.  
  568.             i++;
  569.             j--;
  570.         }
  571.     } while ( i <= j );
  572.  
  573.     if( left < j )    qs_string(a,left,j,count);
  574.     if( i < right )    qs_string(a,i,right,count);
  575. }
  576. /* ----------------------------------------------------------------- */
  577. int    mincmp(a,b)    /* minimum length reqd. to distinguish a, b
  578.                - this relies on the behaviour of strncmp,
  579.                when one or other string is exhausted first */
  580.  
  581. char    *a,*b;
  582. {
  583.     int    i;
  584.     if (!mystrcmp(a,b))
  585.         return(0);        /* cannot distinguish */
  586.  
  587.     if( a == NULL ||  b == NULL )    /* strictly NULLCP */
  588.         return(1);
  589.  
  590.     if( &a == '\0' ||  &b == '\0' )
  591.         return(1);
  592.  
  593.     for(i=1;;i++) {
  594.         /* printf("a %s b %s i %d\n",a,b,i); */
  595.         if(mystrncmp(a,b,i))    /* different at i */
  596.             break;
  597.     }
  598.     return(i);
  599. }
  600. /* ----------------------------------------------------------------- */
  601. mystrcmp(a,b)    /* to avoid null dereference */
  602. char    *a,*b;
  603. {
  604.     if ((a == NULL) && (b == NULL))
  605.         return(0);
  606.  
  607.     if ((a == NULL))
  608.         return(-1);
  609.  
  610.     if ((b == NULL))
  611.         return(1);
  612.  
  613.     return(strcmp(a,b));
  614. }
  615. /* ----------------------------------------------------------------- */
  616. mystrncmp(a,b,i)    /* to avoid null dereference */
  617. char    *a,*b;
  618. int    i;
  619. {
  620.     if ((a == NULL) && (b == NULL))
  621.         return(0);
  622.  
  623.     if ((a == NULL))
  624.         return(-1);
  625.  
  626.     if ((b == NULL))
  627.         return(1);
  628.  
  629.     return(strncmp(a,b,i));
  630. }
  631. /* ----------------------------------------------------------------- */
  632.  
  633. cleanquit ()
  634. {
  635.     exit (1);
  636. }
  637.